home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 5 / Apprentice-Release5.iso / Source Code / C / Applications / Python 1.3.3 / Python 133 PPC / Mac / Lib / toolbox / aetools.py < prev    next >
Text File  |  1996-05-19  |  6KB  |  205 lines
  1. """Tools for use in AppleEvent clients and servers.
  2.  
  3. pack(x) converts a Python object to an AEDesc object
  4. unpack(desc) does the reverse
  5.  
  6. packevent(event, parameters, attributes) sets params and attrs in an AEAppleEvent record
  7. unpackevent(event) returns the parameters and attributes from an AEAppleEvent record
  8.  
  9. Plus...  Lots of classes and routines that help representing AE objects,
  10. ranges, conditionals, logicals, etc., so you can write, e.g.:
  11.  
  12.     x = Character(1, Document("foobar"))
  13.  
  14. and pack(x) will create an AE object reference equivalent to AppleScript's
  15.  
  16.     character 1 of document "foobar"
  17.  
  18. Some of the stuff that appears to be exported from this module comes from other
  19. files: the pack stuff from aepack, the objects from aetypes.
  20.  
  21. """
  22.  
  23.  
  24. from types import *
  25. import AE
  26. import AppleEvents
  27. import MacOS
  28.  
  29. from aetypes import *
  30. from aepack import pack, unpack, coerce, AEDescType
  31.  
  32. # Special code to unpack an AppleEvent (which is *not* a disguised record!)
  33. # Note by Jack: No??!? If I read the docs correctly it *is*....
  34.  
  35. aekeywords = [
  36.     'tran',
  37.     'rtid',
  38.     'evcl',
  39.     'evid',
  40.     'addr',
  41.     'optk',
  42.     'timo',
  43.     'inte',    # this attribute is read only - will be set in AESend
  44.     'esrc',    # this attribute is read only
  45.     'miss',    # this attribute is read only
  46.     'from'    # new in 1.0.1
  47. ]
  48.  
  49. def missed(ae):
  50.     try:
  51.         desc = ae.AEGetAttributeDesc('miss', 'keyw')
  52.     except AE.Error, msg:
  53.         return None
  54.     return desc.data
  55.  
  56. def unpackevent(ae):
  57.     parameters = {}
  58.     while 1:
  59.         key = missed(ae)
  60.         if not key: break
  61.         parameters[key] = unpack(ae.AEGetParamDesc(key, '****'))
  62.     attributes = {}
  63.     for key in aekeywords:
  64.         try:
  65.             desc = ae.AEGetAttributeDesc(key, '****')
  66.         except (AE.Error, MacOS.Error), msg:
  67.             if msg[0] != -1701:
  68.                 raise sys.exc_type, sys.exc_value
  69.             continue
  70.         attributes[key] = unpack(desc)
  71.     return parameters, attributes
  72.  
  73. def packevent(ae, parameters = {}, attributes = {}):
  74.     for key, value in parameters.items():
  75.         ae.AEPutParamDesc(key, pack(value))
  76.     for key, value in attributes.items():
  77.         ae.AEPutAttributeDesc(key, pack(value))
  78.  
  79. #
  80. # Support routine for automatically generated Suite interfaces
  81. # These routines are also useable for the reverse function.
  82. #
  83. def keysubst(arguments, keydict):
  84.     """Replace long name keys by their 4-char counterparts, and check"""
  85.     ok = keydict.values()
  86.     for k in arguments.keys():
  87.         if keydict.has_key(k):
  88.             v = arguments[k]
  89.             del arguments[k]
  90.             arguments[keydict[k]] = v
  91.         elif k != '----' and k not in ok:
  92.             raise TypeError, 'Unknown keyword argument: %s'%k
  93.             
  94. def enumsubst(arguments, key, edict):
  95.     """Substitute a single enum keyword argument, if it occurs"""
  96.     if not arguments.has_key(key):
  97.         return
  98.     v = arguments[key]
  99.     ok = edict.values()
  100.     if edict.has_key(v):
  101.         arguments[key] = edict[v]
  102.     elif not v in ok:
  103.         raise TypeError, 'Unknown enumerator: %s'%v
  104.         
  105. def decodeerror(arguments):
  106.     """Create the 'best' argument for a raise MacOS.Error"""
  107.     errn = arguments['errn']
  108.     errarg = (errn, MacOS.GetErrorString(errn))
  109.     if arguments.has_key('errs'):
  110.         errarg = errarg + (arguments['errs'],)
  111.     if arguments.has_key('erob'):
  112.         errarg = errarg + (arguments['erob'],)
  113.     return errarg
  114.  
  115. class TalkTo:
  116.     """An AE connection to an application"""
  117.     
  118.     def __init__(self, signature):
  119.         """Create a communication channel with a particular application.
  120.         
  121.         Addressing the application is done by specifying either a
  122.         4-byte signature, an AEDesc or an object that will __aepack__
  123.         to an AEDesc.
  124.         """
  125.         if type(signature) == AEDescType:
  126.             self.target = signature
  127.         elif type(signature) == InstanceType and hasattr(signature, '__aepack__'):
  128.             self.target = signature.__aepack__()
  129.         elif type(signature) == StringType and len(signature) == 4:
  130.             self.target = AE.AECreateDesc(AppleEvents.typeApplSignature, signature)
  131.         else:
  132.             raise TypeError, "signature should be 4-char string or AEDesc"
  133.         self.send_flags = AppleEvents.kAEWaitReply
  134.         self.send_priority = AppleEvents.kAENormalPriority
  135.         self.send_timeout = AppleEvents.kAEDefaultTimeout
  136.     
  137.     def newevent(self, code, subcode, parameters = {}, attributes = {}):
  138.         """Create a complete structure for an apple event"""
  139.         
  140.         event = AE.AECreateAppleEvent(code, subcode, self.target,
  141.                     AppleEvents.kAutoGenerateReturnID, AppleEvents.kAnyTransactionID)
  142.         packevent(event, parameters, attributes)
  143.         return event
  144.     
  145.     def sendevent(self, event):
  146.         """Send a pre-created appleevent, await the reply and unpack it"""
  147.         
  148.         reply = event.AESend(self.send_flags, self.send_priority,
  149.                                   self.send_timeout)
  150.         parameters, attributes = unpackevent(reply)
  151.         return reply, parameters, attributes
  152.         
  153.     def send(self, code, subcode, parameters = {}, attributes = {}):
  154.         """Send an appleevent given code/subcode/pars/attrs and unpack the reply"""
  155.         return self.sendevent(self.newevent(code, subcode, parameters, attributes))
  156.     
  157.     #
  158.     # The following events are somehow "standard" and don't seem to appear in any
  159.     # suite...
  160.     #
  161.     def activate(self):
  162.         """Send 'activate' command"""
  163.         self.send('misc', 'actv')
  164.  
  165.     def get(self, _object, _attributes={}):
  166.         """get: get data from an object
  167.         Required argument: the object
  168.         Keyword argument _attributes: AppleEvent attribute dictionary
  169.         Returns: the data
  170.         """
  171.         _code = 'core'
  172.         _subcode = 'getd'
  173.  
  174.         _arguments = {'----':_object}
  175.  
  176.  
  177.         _reply, _arguments, _attributes = self.send(_code, _subcode,
  178.                 _arguments, _attributes)
  179.         if _arguments.has_key('errn'):
  180.             raise MacOS.Error, decodeerror(_arguments)
  181.  
  182.         if _arguments.has_key('----'):
  183.             return _arguments['----']
  184.     
  185.     
  186. # Test program
  187. # XXXX Should test more, really...
  188.  
  189. def test():
  190.     target = AE.AECreateDesc('sign', 'KAHL')
  191.     ae = AE.AECreateAppleEvent('aevt', 'oapp', target, -1, 0)
  192.     print unpackevent(ae)
  193.     raw_input(":")
  194.     ae = AE.AECreateAppleEvent('core', 'getd', target, -1, 0)
  195.     obj = Character(2, Word(1, Document(1)))
  196.     print obj
  197.     print repr(obj)
  198.     packevent(ae, {'----': obj})
  199.     params, attrs = unpackevent(ae)
  200.     print params['----']
  201.     raw_input(":")
  202.  
  203. if __name__ == '__main__':
  204.     test()
  205.